home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 12 / Cream of the Crop 12 (Part II) / Cream of the Crop 12 (Part II).iso / OS2 / DIKUMUD.ZIP / MAGIC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-30  |  54.0 KB  |  2,213 lines
  1. /*
  2.   SillyMUD Distribution V1.1b             (c) 1993 SillyMUD Developement
  3.  
  4.   See license.doc for distribution terms.   SillyMUD is based on DIKUMUD
  5. */
  6.  
  7. #include <stdio.h>
  8. #include <assert.h>
  9.  
  10. #include "protos.h"
  11.  
  12. /* Extern structures */
  13. #if HASH
  14. extern struct hash_header room_db;
  15. #else
  16. extern struct room_data *room_db;
  17. #endif
  18. extern struct obj_data  *object_list;
  19. extern struct char_data *character_list;
  20.  
  21.  
  22. /* For future use in blinding those with infravision who are fireballed
  23.    or otherwise subjected to lotsa heat quickly in dark rooms. */
  24.  
  25. void heat_blind(struct char_data *ch)
  26. {
  27.   struct affected_type af;
  28.   byte tmp;
  29.  
  30.   tmp=number(1,4);
  31.  
  32.   if(!ch)        /* Dunno if this does anything */
  33.     return;
  34.  
  35.   if ( IS_AFFECTED(ch, AFF_BLIND) ) {
  36.     return;            /* no affect */
  37.   }
  38.   else if  ((IS_DARK(ch->in_room)) && (!IS_IMMORTAL(ch)) &&
  39.         (!IS_AFFECTED(ch, AFF_TRUE_SIGHT)) && 
  40.         (IS_AFFECTED(ch, AFF_INFRAVISION)))  {
  41.     send_to_char("Aaarrrggghhh!!  The heat blinds you!!\n\r", ch);
  42.     af.type      = SPELL_BLINDNESS;
  43.     af.location  = APPLY_HITROLL;
  44.     af.modifier  = -4;  /* Make hitroll worse */
  45.     af.duration  = tmp;
  46.     af.bitvector = AFF_BLIND;
  47.     affect_to_char(ch, &af);
  48.   }
  49. }
  50.        
  51.  
  52. /* Offensive Spells */
  53.  
  54. void spell_magic_missile(byte level, struct char_data *ch,
  55.   struct char_data *victim, struct obj_data *obj)
  56. {
  57.   int dam;
  58.  
  59.   assert(victim && ch);
  60.   assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  61.  
  62.   dam = dice((int)(level / 2)+1,4)+(level / 2)+1;
  63.  
  64.   if (affected_by_spell(victim,SPELL_SHIELD))
  65.     dam = 0;
  66.  
  67.   MissileDamage(ch, victim, dam, SPELL_MAGIC_MISSILE);
  68. }
  69.  
  70.  
  71.  
  72. void spell_chill_touch(byte level, struct char_data *ch,
  73.   struct char_data *victim, struct obj_data *obj)
  74. {
  75.   struct affected_type af;
  76.   int dam;
  77.  
  78.   assert(victim && ch);
  79.   assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  80.  
  81.   dam = number(level, 3*level);
  82.  
  83.   if ( !saves_spell(victim, SAVING_SPELL) )
  84.   {
  85.     af.type      = SPELL_CHILL_TOUCH;
  86.     af.duration  = 6;
  87.     af.modifier  = -1;
  88.     af.location  = APPLY_STR;
  89.     af.bitvector = 0;
  90.     affect_join(victim, &af, TRUE, FALSE);
  91.   } else {
  92.     dam >>= 1;
  93.   }
  94.   damage(ch, victim, dam, SPELL_CHILL_TOUCH);
  95. }
  96.  
  97. void spell_burning_hands(byte level, struct char_data *ch,
  98.   struct char_data *victim, struct obj_data *obj)
  99. {
  100.   int dam;
  101.   struct char_data *tmp_victim, *temp;
  102.  
  103.   assert(ch);
  104.   assert((level >= 1) && (level <= ABS_MAX_LVL));
  105.  
  106.   dam = dice(1,4) + level/2 + 1;
  107.  
  108.   send_to_char("Searing flame fans out in front of you!\n\r", ch);
  109.   act("$n sends a fan of flame shooting from the fingertips!\n\r",
  110.       FALSE, ch, 0, 0, TO_ROOM);
  111.  
  112.   for ( tmp_victim = real_roomp(ch->in_room)->people; tmp_victim; 
  113.        tmp_victim = temp ) {
  114.     temp = tmp_victim->next_in_room;
  115.     if ( (ch->in_room == tmp_victim->in_room) && (ch != tmp_victim)) {
  116.       if ((GetMaxLevel(tmp_victim)>LOW_IMMORTAL) && (!IS_NPC(tmp_victim)))
  117.     return;
  118.       if (!in_group(ch, tmp_victim)) {
  119.     act("You are seared by the burning flame!\n\r",
  120.         FALSE, ch, 0, tmp_victim, TO_VICT);
  121.     heat_blind(tmp_victim);
  122.     if ( saves_spell(tmp_victim, SAVING_SPELL) )
  123.       dam = 0;
  124.     MissileDamage(ch, tmp_victim, dam, SPELL_BURNING_HANDS);
  125.       } else {
  126.     act("You are able to avoid the flames!\n\r",
  127.         FALSE, ch, 0, tmp_victim, TO_VICT);
  128.     heat_blind(tmp_victim);
  129.       }
  130.     }
  131.   }
  132. }
  133.  
  134.  
  135.  
  136. void spell_shocking_grasp(byte level, struct char_data *ch,
  137.   struct char_data *victim, struct obj_data *obj)
  138. {
  139.   int dam;
  140.  
  141.   assert(victim && ch);
  142.   assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  143.  
  144.   dam = number(1,8)+level;
  145.  
  146.   if ((GET_HIT(victim) < -4) && IsHumanoid(victim) &&
  147.       !IsUndead(victim)) {
  148.     act ("$n utters the words 'clear', and touches $N's chest", 
  149.      FALSE,ch, 0, victim, TO_ROOM);
  150.     GET_HIT(victim) += dam;
  151.     update_pos(victim);
  152.     return;
  153.   }
  154.  
  155.   if (!HitOrMiss(ch, victim, CalcThaco(ch)))
  156.     dam = 0;
  157.  
  158.   damage(ch, victim, dam, SPELL_SHOCKING_GRASP);
  159. }
  160.  
  161.  
  162.  
  163. void spell_lightning_bolt(byte level, struct char_data *ch,
  164.   struct char_data *victim, struct obj_data *obj)
  165. {
  166.   int dam;
  167.  
  168.   assert(victim && ch);
  169.   assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  170.  
  171.   dam = dice(level,6);
  172.  
  173.   if ( saves_spell(victim, SAVING_SPELL) )
  174.     dam >>= 1;
  175.  
  176.   MissileDamage(ch, victim, dam, SPELL_LIGHTNING_BOLT);
  177. }
  178.  
  179.  
  180.  
  181. void spell_colour_spray(byte level, struct char_data *ch,
  182.   struct char_data *victim, struct obj_data *obj)
  183. {
  184.   int dam;
  185.  
  186.   assert(victim && ch);
  187.   assert((level >= 1) && (level <= ABS_MAX_LVL));
  188.  
  189.   dam = 4 * level;
  190.  
  191.   if ( saves_spell(victim, SAVING_SPELL) )
  192.     dam >>= 1;
  193.  
  194.   MissileDamage(ch, victim, dam, SPELL_COLOUR_SPRAY);
  195.  
  196. }
  197.  
  198.  
  199. /* Drain XP, MANA, HP - caster gains HP and MANA */
  200. void spell_energy_drain(byte level, struct char_data *ch,
  201.   struct char_data *victim, struct obj_data *obj)
  202. {
  203.   int dam;
  204.   int tmp;
  205.  
  206.   void set_title(struct char_data *ch);
  207.   void gain_exp(struct char_data *ch, int gain);
  208.  
  209.   assert(victim && ch);
  210.   assert((level >= 1) && (level <=  ABS_MAX_LVL));
  211.  
  212.   if ( !saves_spell(victim, SAVING_SPELL) ) {
  213.     GET_ALIGNMENT(ch) = MAX(-1000, GET_ALIGNMENT(ch)-200);
  214.  
  215.     if (GetMaxLevel(victim) <= 1) {
  216.       damage(ch, victim, 100, SPELL_ENERGY_DRAIN); /* Kill the sucker */
  217.     } else if ((!IS_NPC(victim)) && (GetMaxLevel(victim) >= LOW_IMMORTAL)) {
  218.       send_to_char("Some puny mortal just tried to drain you...\n\r",victim);
  219.     } else {
  220.  
  221.       if (!IS_SET(victim->M_immune, IMM_DRAIN)) {
  222.  
  223.          send_to_char("Your life energy is drained!\n\r", victim);
  224.      dam = 1;
  225.      damage(ch, victim, dam, SPELL_ENERGY_DRAIN);
  226.      if (!IS_NPC(victim)) {
  227.         drop_level(victim, BestClass(victim));
  228.         set_title(victim);
  229.       } else {
  230.         tmp = GET_MAX_HIT(victim)/GetMaxLevel(victim);
  231.         victim->points.max_hit -=tmp;
  232.         GET_HIT(victim) -= tmp;
  233.         tmp = GET_EXP(victim)/GetMaxLevel(victim);
  234.         GET_EXP(ch)+=tmp;
  235.         GET_EXP(victim)-=tmp;
  236.         victim->points.hitroll+=1;
  237.       }
  238.       } else {
  239.      if (!IS_SET(ch->M_immune, IMM_DRAIN)) {
  240.         send_to_char("Your spell backfires!\n\r",ch);
  241.         dam = 1;
  242.         damage(ch, victim, dam, SPELL_ENERGY_DRAIN);
  243.         if (!IS_NPC(ch)) {
  244.            drop_level(ch, BestClass(ch));
  245.                set_title(ch);
  246.          } else {
  247.            tmp = GET_MAX_HIT(victim)/GetMaxLevel(victim);
  248.            victim->points.max_hit -=tmp;
  249.            GET_HIT(victim) -= tmp;
  250.            victim->points.hitroll+=1;
  251.            tmp = GET_EXP(victim)/GetMaxLevel(victim);
  252.            GET_EXP(ch)+=tmp;
  253.            GET_EXP(victim)-=tmp;
  254.          }
  255.          } else {
  256.        send_to_char("Your spell fails utterly.\n\r",ch);
  257.      }
  258.        }
  259.  
  260.      }
  261.   } else {
  262.     damage(ch, victim, 0, SPELL_ENERGY_DRAIN); /* Miss */
  263.   }
  264. }
  265.  
  266.  
  267.  
  268. void spell_fireball(byte level, struct char_data *ch,
  269.   struct char_data *victim, struct obj_data *obj)
  270. {
  271.   int dam;
  272.   struct char_data *tmp_victim, *temp;
  273.  
  274.   assert(ch);
  275.   assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  276.  
  277.   dam = dice(level,8);
  278.  
  279. /*
  280.   this one should be in_world, not in room, so that the message can
  281.   be sent to everyone.
  282. */
  283.  
  284.    for(tmp_victim = character_list; tmp_victim; tmp_victim = temp) {
  285.       temp = tmp_victim->next;
  286.       if ( (ch->in_room == tmp_victim->in_room) && (ch != tmp_victim)) {
  287.          if (!in_group(ch,tmp_victim) && !IS_IMMORTAL(tmp_victim)) {
  288.        if ( saves_spell(tmp_victim, SAVING_SPELL) )
  289.          dam >>= 1;
  290.        heat_blind(tmp_victim);
  291.        MissileDamage(ch, tmp_victim, dam, SPELL_FIREBALL);
  292.      } else {
  293.             act("You dodge the mass of flame!!\n\r",
  294.                  FALSE, ch, 0, tmp_victim, TO_VICT);
  295.         heat_blind(tmp_victim);
  296.      }
  297.       } else {
  298.      if (tmp_victim->in_room != NOWHERE) {
  299.             if (real_roomp(ch->in_room)->zone == 
  300.         real_roomp(tmp_victim->in_room)->zone) {
  301.                 send_to_char("You feel a blast of hot air.\n\r", tmp_victim);
  302.         }
  303.      }
  304.       }
  305.    } 
  306. }
  307.  
  308.  
  309. void spell_earthquake(byte level, struct char_data *ch,
  310.   struct char_data *victim, struct obj_data *obj)
  311. {
  312.   int dam;
  313.  
  314.   struct char_data *tmp_victim, *temp;
  315.  
  316.   assert(ch);
  317.   assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  318.  
  319.   dam =  dice(1,4) + level + 1;
  320.  
  321.   send_to_char("The earth trembles beneath your feet!\n\r", ch);
  322.   act("$n makes the earth tremble and shiver",
  323.       FALSE, ch, 0, 0, TO_ROOM);
  324.  
  325.   for(tmp_victim = character_list; tmp_victim; tmp_victim = temp) {
  326.     temp = tmp_victim->next;
  327.     if ( (ch->in_room == tmp_victim->in_room) && (ch != tmp_victim)) {
  328.       if (!in_group(ch,tmp_victim) && !IS_IMMORTAL(tmp_victim)) {
  329.     
  330.      if (GetMaxLevel(tmp_victim) > 4) {
  331.        act("You fall and hurt yourself!!\n\r",
  332.            FALSE, ch, 0, tmp_victim, TO_VICT);
  333.        MissileDamage(ch, tmp_victim, dam, SPELL_EARTHQUAKE);
  334.      } else {
  335.        act("You are sucked into a huge hole in the ground!", FALSE,
  336.            ch, 0, tmp_victim, TO_VICT);
  337.        act("$N is sucked into a huge hole in the ground!", FALSE,
  338.            ch, 0, tmp_victim, TO_NOTVICT);
  339.        MissileDamage(ch, tmp_victim, GET_MAX_HIT(tmp_victim)*12, 
  340.              SPELL_EARTHQUAKE);
  341.      }
  342.        } else {
  343.      act("You almost fall and hurt yourself!!\n\r",
  344.          FALSE, ch, 0, tmp_victim, TO_VICT);
  345.        }
  346.     } else {
  347.       if (real_roomp(ch->in_room)->zone == 
  348.       real_roomp(tmp_victim->in_room)->zone)
  349.     send_to_char("The earth trembles...\n\r", tmp_victim);
  350.     }
  351.   } 
  352. }
  353.  
  354.  
  355.  
  356. void spell_dispel_evil(byte level, struct char_data *ch,
  357.   struct char_data *victim, struct obj_data *obj)
  358. {
  359.   int dam=1;
  360.   assert(ch && victim);
  361.   assert((level >= 1) && (level<=ABS_MAX_LVL));
  362.     
  363.   
  364.   if (IsExtraPlanar(victim)) {
  365.     if (IS_EVIL(ch)) {
  366.       victim = ch;
  367.     } else {
  368.       if (IS_GOOD(victim)) {
  369.     act("Good protects $N.", FALSE, ch, 0, victim, TO_CHAR);
  370.     return;
  371.       }
  372.     }
  373.     if (!saves_spell(victim, SAVING_SPELL) ) {
  374.       act("$n forces $N from this plane.", TRUE, ch, 0, victim, TO_ROOM);
  375.       act("You force $N from this plane.", TRUE, ch, 0, victim, TO_CHAR);
  376.       act("$n forces you from this plane.", TRUE, ch, 0, victim,TO_VICT);
  377.       gain_exp(ch, GET_EXP(victim)/2);
  378.       extract_char(victim);
  379.     } else {
  380.       act("$N resists the attack",TRUE, ch, 0, victim, TO_CHAR);
  381.       act("you resist $n's attack.", TRUE, ch, 0, victim, TO_VICT);
  382.       damage(ch, victim, dam, SPELL_EARTHQUAKE);
  383.     }
  384.   } else {
  385.     act("$N laughs at you.", TRUE, ch, 0, victim, TO_CHAR);
  386.     act("$N laughs at $n.", TRUE,ch, 0, victim, TO_NOTVICT);
  387.     act("You laugh at $n.", TRUE,ch,0,victim,TO_VICT);
  388.   }
  389. }
  390.  
  391.  
  392. void spell_call_lightning(byte level, struct char_data *ch,
  393.               struct char_data *victim, struct obj_data *obj)
  394. {
  395.   int dam;
  396.   
  397.   extern struct weather_data weather_info;
  398.   
  399.   assert(victim && ch);
  400.   assert((level >= 1) && (level <= ABS_MAX_LVL));
  401.   
  402.   dam = dice( level+2, 8);
  403.   
  404.   if (OUTSIDE(ch) && (weather_info.sky>=SKY_RAINING)) {
  405.     
  406.     if ( saves_spell(victim, SAVING_SPELL) )
  407.       dam >>= 1;
  408.     
  409.     MissileDamage(ch, victim, dam, SPELL_CALL_LIGHTNING);
  410.   } else {
  411.     send_to_char("The proper atmospheric conditions are not at hand.\n\r", ch);
  412.     return;
  413.   } 
  414. }
  415.  
  416.  
  417.  
  418. void spell_harm(byte level, struct char_data *ch,
  419.         struct char_data *victim, struct obj_data *obj)
  420. {
  421.   int dam;
  422.   
  423.   assert(victim && ch);
  424.   assert((level >= 1) && (level <= ABS_MAX_LVL));
  425.   
  426.   dam = GET_HIT(victim) - dice(1,4);
  427.   
  428.   if (dam < 0)
  429.     dam = 100; /* Kill the suffering bastard */
  430.   else {
  431.     if (GET_RACE(ch) == RACE_GOD)
  432.       dam = 0;
  433.     if (!HitOrMiss(ch, victim, CalcThaco(ch)))
  434.       dam = 0;
  435.   }
  436.   dam = MIN(dam, 100);
  437.   
  438.   damage(ch, victim, dam, SPELL_HARM);
  439.  
  440.   if (IS_PC(ch) && IS_PC(victim))
  441.     GET_ALIGNMENT(ch)-=4;
  442.  
  443. }
  444.  
  445.  
  446.  
  447. /* spells2.c - Not directly offensive spells */
  448.  
  449. void spell_armor(byte level, struct char_data *ch,
  450.          struct char_data *victim, struct obj_data *obj)
  451. {
  452.   struct affected_type af;
  453.   
  454.   assert(victim);
  455.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  456.   
  457.   if (!affected_by_spell(victim, SPELL_ARMOR)) {
  458.     af.type      = SPELL_ARMOR;
  459.     af.duration  = 24;
  460.     af.modifier  = -20;
  461.     af.location  = APPLY_AC;
  462.     af.bitvector = 0;
  463.     
  464.     affect_to_char(victim, &af);
  465.     send_to_char("You feel someone protecting you.\n\r", victim);
  466.   } else {
  467.     send_to_char("Nothing New seems to happen\n\r", ch);
  468.   }
  469. }
  470.  
  471. #define ASTRAL_ENTRANCE   2700
  472.  
  473. void spell_astral_walk(byte level, struct char_data *ch,
  474.                struct char_data *victim, struct obj_data *obj)
  475. {
  476.   struct char_data *tmp, *tmp2;
  477.   struct room_data *rp;
  478.  
  479.   rp = real_roomp(ch->in_room);
  480.   
  481.   for (tmp = rp->people;tmp;tmp=tmp2) {
  482.     tmp2 = tmp->next_in_room;
  483.     if (in_group(ch, tmp)) {
  484.       act("$n wavers, fades and dissapears", FALSE, tmp, 0, 0, TO_ROOM);
  485.       char_from_room(tmp);
  486.       char_to_room(tmp, ASTRAL_ENTRANCE);      
  487.       do_look(tmp, "\0", 0);
  488.     }
  489.   }  
  490. }
  491.  
  492. void spell_teleport(byte level, struct char_data *ch,
  493.   struct char_data *victim, struct obj_data *obj)
  494. {
  495.   int to_room, try = 0;
  496.   extern int top_of_world;      /* ref to the top element of world */
  497.   struct room_data *room;
  498.   
  499.   assert(ch && victim);
  500.   
  501.   if (victim != ch) {
  502.     if (saves_spell(victim,SAVING_SPELL)) {
  503.       send_to_char("Your spell has no effect.\n\r",ch);
  504.       if (IS_NPC(victim)) {
  505.     if (!victim->specials.fighting)
  506.       set_fighting(victim, ch);
  507.       } else {
  508.     send_to_char("You feel strange, but the effect fades.\n\r",victim);
  509.       }
  510.       return;
  511.     } else {
  512.       ch = victim;  /* the character (target) is now the victim */
  513.     }
  514.   }
  515.  
  516.   if (!IsOnPmp(victim->in_room)) {
  517.     send_to_char("You're on an extra-dimensional plane!\n\r", ch);
  518.     return;
  519.   }
  520.  
  521.   
  522.   do {
  523.     to_room = number(0, top_of_world);
  524.     room = real_roomp(to_room);
  525.     if (room) {
  526.       if ((IS_SET(room->room_flags, PRIVATE)) ||
  527.       (IS_SET(room->room_flags, TUNNEL)) ||
  528.       (IS_SET(room->room_flags, NO_SUM)) ||
  529.       (IS_SET(room->room_flags, NO_MAGIC)) ||
  530.       !IsOnPmp(to_room)) {
  531.     room = 0;
  532.         try++;
  533.     }
  534.     }
  535.     
  536.   } while (!room && try < 10);
  537.   
  538.   if (try >= 10) {
  539.     send_to_char("The magic fails.\n\r", ch);
  540.     return;
  541.   }
  542.  
  543.   act("$n slowly fade out of existence.", FALSE, ch,0,0,TO_ROOM);
  544.   char_from_room(ch);
  545.   char_to_room(ch, to_room);
  546.   act("$n slowly fade in to existence.", FALSE, ch,0,0,TO_ROOM);
  547.   
  548.   do_look(ch, "", 0);
  549.   
  550.   if (IS_SET(real_roomp(to_room)->room_flags, DEATH) && 
  551.       GetMaxLevel(ch) < LOW_IMMORTAL) {
  552.     NailThisSucker(ch);
  553.     return;
  554.   }
  555.  
  556.   check_falling(ch);
  557.  
  558. }
  559.  
  560.  
  561.  
  562. void spell_bless(byte level, struct char_data *ch,
  563.          struct char_data *victim, struct obj_data *obj)
  564. {
  565.   struct affected_type af;
  566.   
  567.   assert(ch && (victim || obj));
  568.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  569.   
  570.   if (obj) {
  571.     if ( (5*GET_LEVEL(ch,CLERIC_LEVEL_IND) > GET_OBJ_WEIGHT(obj)) &&
  572.     (GET_POS(ch) != POSITION_FIGHTING) &&
  573.     !IS_OBJ_STAT(obj, ITEM_ANTI_GOOD)) {
  574.       SET_BIT(obj->obj_flags.extra_flags, ITEM_BLESS);
  575.       act("$p briefly glows.",FALSE,ch,obj,0,TO_CHAR);
  576.     }
  577.   } else {
  578.     
  579.     if ((GET_POS(victim) != POSITION_FIGHTING) &&
  580.     (!affected_by_spell(victim, SPELL_BLESS))) {
  581.       
  582.       send_to_char("You feel righteous.\n\r", victim);
  583.       af.type      = SPELL_BLESS;
  584.       af.duration  = 6;
  585.       af.modifier  = 1;
  586.       af.location  = APPLY_HITROLL;
  587.       af.bitvector = 0;
  588.       affect_to_char(victim, &af);
  589.       
  590.       af.location = APPLY_SAVING_SPELL;
  591.       af.modifier = -1;                 /* Make better */
  592.       affect_to_char(victim, &af);
  593.     }
  594.   }
  595. }
  596.  
  597.  
  598.  
  599. void spell_blindness(byte level, struct char_data *ch,
  600.   struct char_data *victim, struct obj_data *obj)
  601. {
  602.   struct affected_type af;
  603.  
  604.   assert(ch && victim);
  605.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  606.  
  607.  
  608.   if (saves_spell(victim, SAVING_SPELL) ||
  609.        affected_by_spell(victim, SPELL_BLINDNESS))
  610.         return;
  611.  
  612.   act("$n seems to be blinded!", TRUE, victim, 0, 0, TO_ROOM);
  613.   send_to_char("You have been blinded!\n\r", victim);
  614.  
  615.   af.type      = SPELL_BLINDNESS;
  616.   af.location  = APPLY_HITROLL;
  617.   af.modifier  = -4;  /* Make hitroll worse */
  618.   af.duration  = level / 2;
  619.   af.bitvector = AFF_BLIND;
  620.   affect_to_char(victim, &af);
  621.  
  622.  
  623.   af.location = APPLY_AC;
  624.   af.modifier = +20; /* Make AC Worse! */
  625.   affect_to_char(victim, &af);
  626.  
  627.   if ((!victim->specials.fighting)&&(victim!=ch))
  628.      set_fighting(victim,ch);
  629.  
  630. }
  631.  
  632.  
  633.  
  634. void spell_clone(byte level, struct char_data *ch,
  635.   struct char_data *victim, struct obj_data *obj)
  636. {
  637.  
  638.   assert(ch && (victim || obj));
  639.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  640.  
  641.     send_to_char("Clone is not ready yet.", ch);
  642.  
  643.   if (obj) {
  644.  
  645.     } else {
  646.         /* clone_char(victim); */
  647.     }
  648. }
  649.  
  650.  
  651.  
  652. void spell_control_weather(byte level, struct char_data *ch,
  653.   struct char_data *victim, struct obj_data *obj)
  654. {
  655.    /* Control Weather is not possible here!!! */
  656.    /* Better/Worse can not be transferred     */
  657. }
  658.  
  659.  
  660.  
  661. void spell_create_food(byte level, struct char_data *ch,
  662.   struct char_data *victim, struct obj_data *obj)
  663. {
  664.   struct obj_data *tmp_obj;
  665.  
  666.   assert(ch);
  667.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  668.  
  669.   CREATE(tmp_obj, struct obj_data, 1);
  670.   clear_object(tmp_obj);
  671.  
  672.   tmp_obj->name = strdup("mushroom");
  673.   tmp_obj->short_description = strdup("A Magic Mushroom");
  674.   tmp_obj->description = strdup("A really delicious looking magic mushroom lies here.");
  675.  
  676.   tmp_obj->obj_flags.type_flag = ITEM_FOOD;
  677.   tmp_obj->obj_flags.wear_flags = ITEM_TAKE | ITEM_HOLD;
  678.   tmp_obj->obj_flags.value[0] = 5+level;
  679.   tmp_obj->obj_flags.weight = 1;
  680.   tmp_obj->obj_flags.cost = 10;
  681.   tmp_obj->obj_flags.cost_per_day = 1;
  682.  
  683.   tmp_obj->next = object_list;
  684.   object_list = tmp_obj;
  685.  
  686.   obj_to_room(tmp_obj,ch->in_room);
  687.  
  688.   tmp_obj->item_number = -1;
  689.  
  690.   act("$p suddenly appears.",TRUE,ch,tmp_obj,0,TO_ROOM);
  691.   act("$p suddenly appears.",TRUE,ch,tmp_obj,0,TO_CHAR);
  692. }
  693.  
  694.  
  695.  
  696. void spell_create_water(byte level, struct char_data *ch,
  697.   struct char_data *victim, struct obj_data *obj)
  698. {
  699.     int water;
  700.  
  701.   extern struct weather_data weather_info;
  702.     void name_to_drinkcon(struct obj_data *obj,int type);
  703.     void name_from_drinkcon(struct obj_data *obj);
  704.  
  705.   assert(ch && obj);
  706.  
  707.     if (GET_ITEM_TYPE(obj) == ITEM_DRINKCON) {
  708.         if ((obj->obj_flags.value[2] != LIQ_WATER)
  709.              && (obj->obj_flags.value[1] != 0)) {
  710.  
  711.             name_from_drinkcon(obj);
  712.             obj->obj_flags.value[2] = LIQ_SLIME;
  713.             name_to_drinkcon(obj, LIQ_SLIME);
  714.  
  715.         } else {
  716.  
  717.             water = 2*level * ((weather_info.sky >= SKY_RAINING) ? 2 : 1);
  718.  
  719.             /* Calculate water it can contain, or water created */
  720.             water = MIN(obj->obj_flags.value[0]-obj->obj_flags.value[1], water);
  721.  
  722.             if (water > 0) {
  723.               obj->obj_flags.value[2] = LIQ_WATER;
  724.                 obj->obj_flags.value[1] += water;
  725.  
  726.                 weight_change_object(obj, water);
  727.  
  728.                 name_from_drinkcon(obj);
  729.                 name_to_drinkcon(obj, LIQ_WATER);
  730.                 act("$p is partially filled.", FALSE, ch,obj,0,TO_CHAR);
  731.             }
  732.         }
  733.     }
  734. }
  735.  
  736.  
  737.  
  738. void spell_cure_blind(byte level, struct char_data *ch,
  739.   struct char_data *victim, struct obj_data *obj)
  740. {
  741.   assert(victim);
  742.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  743.  
  744.   if (IS_AFFECTED(victim, AFF_BLIND)) {
  745.     REMOVE_BIT(victim->specials.affected_by, AFF_BLIND);
  746.     send_to_char("Your vision returns!\n\r", victim);
  747.   }
  748.  
  749.   if (affected_by_spell(victim, SPELL_BLINDNESS)) {
  750.     affect_from_char(victim, SPELL_BLINDNESS);    
  751.     send_to_char("Your vision returns!\n\r", victim);
  752.   }
  753.   if (IS_PC(ch) && IS_PC(victim))
  754.     GET_ALIGNMENT(ch)+=1;
  755.  
  756. }
  757.  
  758.  
  759.  
  760. void spell_cure_critic(byte level, struct char_data *ch,
  761.   struct char_data *victim, struct obj_data *obj)
  762. {
  763.   int healpoints;
  764.  
  765.   assert(victim);
  766.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  767.  
  768.   healpoints = dice(3,8)+3;
  769.  
  770.   if ( (healpoints + GET_HIT(victim)) > hit_limit(victim) )
  771.     GET_HIT(victim) = hit_limit(victim);
  772.   else
  773.     GET_HIT(victim) += healpoints;
  774.  
  775.   send_to_char("You feel better!\n\r", victim);
  776.  
  777.   update_pos(victim);
  778. /*
  779.   if (IS_PC(ch) && IS_PC(victim))
  780.     GET_ALIGNMENT(ch)+=3;
  781. */
  782. }
  783.  
  784.  
  785. void spell_cure_light(byte level, struct char_data *ch,
  786.   struct char_data *victim, struct obj_data *obj)
  787. {
  788.   int healpoints;
  789.  
  790.   assert(victim);
  791.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  792.  
  793.   healpoints = dice(1,8);
  794.  
  795.   if ( (healpoints + GET_HIT(victim)) > hit_limit(victim) )
  796.     GET_HIT(victim) = hit_limit(victim);
  797.   else
  798.     GET_HIT(victim) += healpoints;
  799.  
  800.   send_to_char("You feel better!\n\r", victim);
  801.  
  802.   update_pos(victim);
  803. /*
  804.   if (IS_PC(ch) && IS_PC(victim))
  805.     GET_ALIGNMENT(ch)+=1;
  806. */
  807. }
  808.  
  809.  
  810.  
  811.  
  812.  
  813. void spell_curse(byte level, struct char_data *ch,
  814.   struct char_data *victim, struct obj_data *obj)
  815. {
  816.   struct affected_type af;
  817.  
  818.   assert(victim || obj);
  819.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  820.  
  821.   if (obj) {
  822.     SET_BIT(obj->obj_flags.extra_flags, ITEM_ANTI_GOOD);
  823.     SET_BIT(obj->obj_flags.extra_flags, ITEM_NODROP);
  824.  
  825.     /* LOWER ATTACK DICE BY -1 */
  826.     if(obj->obj_flags.type_flag == ITEM_WEAPON)
  827.       obj->obj_flags.value[2]--;
  828.         act("$p glows red.", FALSE, ch, obj, 0, TO_CHAR);
  829.   } else {
  830.     if ( saves_spell(victim, SAVING_SPELL) ||
  831.            affected_by_spell(victim, SPELL_CURSE))
  832.       return;
  833.  
  834.     af.type      = SPELL_CURSE;
  835.     af.duration  = 24*7;       /* 7 Days */
  836.     af.modifier  = -1;
  837.     af.location  = APPLY_HITROLL;
  838.     af.bitvector = AFF_CURSE;
  839.     affect_to_char(victim, &af);
  840.  
  841.     af.location = APPLY_SAVING_PARA;
  842.     af.modifier = 1; /* Make worse */
  843.     affect_to_char(victim, &af);
  844.  
  845.     act("$n briefly reveal a red aura!", FALSE, victim, 0, 0, TO_ROOM);
  846.     act("You feel very uncomfortable.",FALSE,victim,0,0,TO_CHAR);
  847.     if (IS_NPC(victim) && !victim->specials.fighting)
  848.        set_fighting(victim,ch);
  849.  
  850.     if (IS_PC(ch) && IS_PC(victim))
  851.       GET_ALIGNMENT(ch)-=2;
  852.  
  853.    }
  854. }
  855.  
  856.  
  857.  
  858. void spell_detect_evil(byte level, struct char_data *ch,
  859.   struct char_data *victim, struct obj_data *obj)
  860. {
  861.   struct affected_type af;
  862.  
  863.   assert(victim);
  864.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  865.   
  866.   if ( affected_by_spell(victim, SPELL_DETECT_EVIL) )
  867.     return;
  868.   
  869.   af.type      = SPELL_DETECT_EVIL;
  870.   af.duration  = level*5;
  871.   af.modifier  = 0;
  872.   af.location  = APPLY_NONE;
  873.   af.bitvector = AFF_DETECT_EVIL;
  874.  
  875.   affect_to_char(victim, &af);
  876.  
  877.   act("$n's eyes briefly glow white", FALSE, victim, 0, 0, TO_ROOM);
  878.   send_to_char("Your eyes tingle.\n\r", victim);
  879. }
  880.  
  881.  
  882.  
  883. void spell_detect_invisibility(byte level, struct char_data *ch,
  884.   struct char_data *victim, struct obj_data *obj)
  885. {
  886.   struct affected_type af;
  887.  
  888.   assert(ch && victim);
  889.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  890.  
  891.   if ( affected_by_spell(victim, SPELL_DETECT_INVISIBLE) )
  892.         return;
  893.  
  894.   af.type      = SPELL_DETECT_INVISIBLE;
  895.   af.duration  = level*5;
  896.   af.modifier  = 0;
  897.   af.location  = APPLY_NONE;
  898.   af.bitvector = AFF_DETECT_INVISIBLE;
  899.  
  900.   affect_to_char(victim, &af);
  901.   act("$n's eyes briefly glow yellow", FALSE, victim, 0, 0, TO_ROOM);
  902.   send_to_char("Your eyes tingle.\n\r", victim);
  903. }
  904.  
  905.  
  906.  
  907. void spell_detect_magic(byte level, struct char_data *ch,
  908.   struct char_data *victim, struct obj_data *obj)
  909. {
  910.   struct affected_type af;
  911.  
  912.   assert(victim);
  913.   assert((level >= 0) && (level <= ABS_MAX_LVL));
  914.  
  915.   if ( affected_by_spell(victim, SPELL_DETECT_MAGIC) )
  916.         return;
  917.  
  918.   af.type      = SPELL_DETECT_MAGIC;
  919.   af.duration  = level*5;
  920.   af.modifier  = 0;
  921.   af.location  = APPLY_NONE;
  922.   af.bitvector = AFF_DETECT_MAGIC;
  923.  
  924.   affect_to_char(victim, &af);
  925.   send_to_char("Your eyes tingle.\n\r", victim);
  926. }
  927.  
  928.  
  929.  
  930. void spell_detect_poison(byte level, struct char_data *ch,
  931.   struct char_data *victim, struct obj_data *obj)
  932. {
  933.     assert(ch && (victim || obj));
  934.  
  935.   if (victim) {
  936.     if (victim == ch)
  937.       if (IS_AFFECTED(victim, AFF_POISON))
  938.         send_to_char("You can sense poison in your blood.\n\r", ch);
  939.       else
  940.         send_to_char("You feel healthy.\n\r", ch);
  941.     else
  942.       if (IS_AFFECTED(victim, AFF_POISON)) {
  943.         act("You sense that $E is poisoned.",FALSE,ch,0,victim,TO_CHAR);
  944.       } else {
  945.         act("You sense that $E is poisoned",FALSE,ch,0,victim,TO_CHAR);
  946.       }
  947.   } else { /* It's an object */
  948.     if ((obj->obj_flags.type_flag == ITEM_DRINKCON) ||
  949.         (obj->obj_flags.type_flag == ITEM_FOOD)) {
  950.       if (obj->obj_flags.value[3])
  951.         act("Poisonous fumes are revealed.",FALSE, ch, 0, 0, TO_CHAR);
  952.       else
  953.         send_to_char("It looks very delicious.\n\r", ch);
  954.     }
  955.   }
  956. }
  957.  
  958.  
  959.  
  960. void spell_enchant_weapon(byte level, struct char_data *ch,
  961.   struct char_data *victim, struct obj_data *obj)
  962. {
  963.   int i;
  964.   int count=0;
  965.   
  966.   assert(ch && obj);
  967.   assert(MAX_OBJ_AFFECT >= 2);
  968.   
  969.   if ((GET_ITEM_TYPE(obj) == ITEM_WEAPON) &&
  970.       !IS_SET(obj->obj_flags.extra_flags, ITEM_MAGIC)) {
  971.     
  972.     for (i=0; i < MAX_OBJ_AFFECT; i++) {
  973.       if (obj->affected[i].location == APPLY_NONE) 
  974.     count++;
  975.       if (obj->affected[i].location == APPLY_HITNDAM ||
  976.           obj->affected[i].location == APPLY_HITROLL ||
  977.           obj->affected[i].location == APPLY_DAMROLL)
  978.     return;
  979.     }
  980.  
  981.     if (count < 2) return;
  982.     /*  find the slots */
  983.     i = getFreeAffSlot(obj);
  984.     
  985.     SET_BIT(obj->obj_flags.extra_flags, ITEM_MAGIC);
  986.     
  987.     obj->affected[i].location = APPLY_HITROLL;
  988.     obj->affected[i].modifier = 1;
  989.     if (level > 20)
  990.       obj->affected[i].modifier += 1;
  991.     if (level > 40)
  992.       obj->affected[i].modifier += 1;
  993.     if (level > MAX_MORT)
  994.       obj->affected[i].modifier += 1;
  995.     if (level == LOKI)
  996.       obj->affected[i].modifier += 1;
  997.     
  998.     i = getFreeAffSlot(obj);
  999.     
  1000.     obj->affected[i].location = APPLY_DAMROLL;        
  1001.     obj->affected[i].modifier = 1;
  1002.     if (level > 15)
  1003.       obj->affected[i].modifier += 1;
  1004.     if (level > 30)
  1005.       obj->affected[i].modifier += 1;
  1006.     if (level > MAX_MORT)
  1007.       obj->affected[i].modifier += 1;
  1008.     if (level == LOKI)
  1009.       obj->affected[i].modifier += 1;
  1010.     
  1011.     if (IS_GOOD(ch)) {
  1012.       SET_BIT(obj->obj_flags.extra_flags, ITEM_ANTI_EVIL|ITEM_ANTI_NEUTRAL);
  1013.       act("$p glows blue.",FALSE,ch,obj,0,TO_CHAR);
  1014.     } else if (IS_EVIL(ch)) {
  1015.       SET_BIT(obj->obj_flags.extra_flags, ITEM_ANTI_GOOD|ITEM_ANTI_NEUTRAL);
  1016.       act("$p glows red.",FALSE,ch,obj,0,TO_CHAR);
  1017.     } else {
  1018.       act("$p glows yellow.",FALSE,ch,obj,0,TO_CHAR);
  1019.       SET_BIT(obj->obj_flags.extra_flags, ITEM_ANTI_GOOD|ITEM_ANTI_EVIL);
  1020.     }
  1021.   }
  1022. }
  1023.  
  1024. void spell_enchant_armor(byte level, struct char_data *ch,
  1025.   struct char_data *victim, struct obj_data *obj)
  1026. {
  1027.   int i;
  1028.   int count=0;
  1029.   
  1030.   assert(ch && obj);
  1031.   assert(MAX_OBJ_AFFECT >= 2);
  1032.   
  1033.   if ((GET_ITEM_TYPE(obj) == ITEM_ARMOR) &&
  1034.       !IS_SET(obj->obj_flags.extra_flags, ITEM_MAGIC)) {
  1035.     
  1036.     for (i=0; i < MAX_OBJ_AFFECT; i++) {
  1037.       if (obj->affected[i].location == APPLY_NONE) 
  1038.     count++;
  1039.       if (obj->affected[i].location == APPLY_ARMOR ||
  1040.           obj->affected[i].location == APPLY_SAVE_ALL ||
  1041.           obj->affected[i].location == APPLY_SAVING_PARA ||
  1042.           obj->affected[i].location == APPLY_SAVING_ROD ||
  1043.           obj->affected[i].location == APPLY_SAVING_PETRI ||
  1044.           obj->affected[i].location == APPLY_SAVING_BREATH ||
  1045.           obj->affected[i].location == APPLY_SAVING_SPELL ||
  1046.           obj->affected[i].location == APPLY_SAVE_ALL)
  1047.     return;
  1048.     }
  1049.  
  1050.     if (count < 2) return;
  1051.     /*  find the slots */
  1052.     i = getFreeAffSlot(obj);
  1053.     
  1054.     SET_BIT(obj->obj_flags.extra_flags, ITEM_MAGIC);
  1055.     
  1056.     obj->affected[i].location = APPLY_ARMOR;
  1057.     obj->affected[i].modifier = -5;
  1058.     if (level > 20)
  1059.       obj->affected[i].modifier -= 5;
  1060.     if (level > 40)
  1061.       obj->affected[i].modifier -= 5;
  1062.     if (level > MAX_MORT)
  1063.       obj->affected[i].modifier -= 5;
  1064.     if (level == LOKI)
  1065.       obj->affected[i].modifier -= 5;
  1066.     
  1067.     i = getFreeAffSlot(obj);
  1068.     
  1069.     obj->affected[i].location = APPLY_SAVE_ALL;        
  1070.     obj->affected[i].modifier = 0;
  1071.     if (level > 30)
  1072.       obj->affected[i].modifier += 1;
  1073.     if (level > MAX_MORT)
  1074.       obj->affected[i].modifier += 1;
  1075.     if (level == LOKI)
  1076.       obj->affected[i].modifier += 1;
  1077.     
  1078.     if (IS_GOOD(ch)) {
  1079.       SET_BIT(obj->obj_flags.extra_flags, ITEM_ANTI_EVIL|ITEM_ANTI_NEUTRAL);
  1080.       act("$p glows blue.",FALSE,ch,obj,0,TO_CHAR);
  1081.     } else if (IS_EVIL(ch)) {
  1082.       SET_BIT(obj->obj_flags.extra_flags, ITEM_ANTI_GOOD|ITEM_ANTI_NEUTRAL);
  1083.       act("$p glows red.",FALSE,ch,obj,0,TO_CHAR);
  1084.     } else {
  1085.       act("$p glows yellow.",FALSE,ch,obj,0,TO_CHAR);
  1086.       SET_BIT(obj->obj_flags.extra_flags, ITEM_ANTI_GOOD|ITEM_ANTI_EVIL);
  1087.     }
  1088.   }
  1089. }
  1090.  
  1091.  
  1092.  
  1093. void spell_heal(byte level, struct char_data *ch,
  1094.   struct char_data *victim, struct obj_data *obj)
  1095. {
  1096.   assert(victim);
  1097.  
  1098.   spell_cure_blind(level, ch, victim, obj);
  1099.  
  1100.   GET_HIT(victim) += 100;
  1101.  
  1102.   if (GET_HIT(victim) >= hit_limit(victim))
  1103.     GET_HIT(victim) = hit_limit(victim)-dice(1,4);
  1104.  
  1105.   update_pos( victim );
  1106.  
  1107.   send_to_char("A warm feeling fills your body.\n\r", victim);
  1108.  
  1109.   if (IS_PC(ch) && IS_PC(victim))
  1110.     GET_ALIGNMENT(ch)+=5;
  1111.  
  1112. }
  1113.  
  1114.  
  1115. void spell_invisibility(byte level, struct char_data *ch,
  1116.   struct char_data *victim, struct obj_data *obj)
  1117. {
  1118.   struct affected_type af;
  1119.  
  1120.     assert((ch && obj) || victim);
  1121.  
  1122.   if (obj) {
  1123.     if ( !IS_SET(obj->obj_flags.extra_flags, ITEM_INVISIBLE) ) {
  1124.             act("$p turns invisible.",FALSE,ch,obj,0,TO_CHAR);
  1125.             act("$p turns invisible.",TRUE,ch,obj,0,TO_ROOM);
  1126.       SET_BIT(obj->obj_flags.extra_flags, ITEM_INVISIBLE);
  1127.         }
  1128.   } else {              /* Then it is a PC | NPC */
  1129.         if (!affected_by_spell(victim, SPELL_INVISIBLE)) {
  1130.  
  1131.           act("$n slowly fades out of existence.", TRUE, victim,0,0,TO_ROOM);
  1132.         send_to_char("You vanish.\n\r", victim);
  1133.  
  1134.         af.type      = SPELL_INVISIBLE;
  1135.         af.duration  = 24;
  1136.         af.modifier  = -40;
  1137.         af.location  = APPLY_AC;
  1138.         af.bitvector = AFF_INVISIBLE;
  1139.         affect_to_char(victim, &af);
  1140.       }
  1141.     }
  1142. }
  1143.  
  1144.  
  1145. void spell_locate_object(byte level, struct char_data *ch,
  1146.              struct char_data *victim, struct obj_data *obj)
  1147. {
  1148.   struct obj_data *i;
  1149.   char name[256], buf2[256];
  1150.   char buf[MAX_STRING_LENGTH];
  1151.   int j;
  1152.  
  1153.     assert(ch);
  1154.  
  1155.   if (!obj) {
  1156.     send_to_char("locate what??\n\r",ch);
  1157.     return;
  1158.   }
  1159.  
  1160.   if (!obj->name || !(*obj->name)) {
  1161.     send_to_char("which object?\n\r", ch);
  1162.     return;
  1163.   }
  1164.     
  1165.  
  1166.   strcpy(name, obj->name);
  1167.  
  1168.   j=level>>1;
  1169.   sprintf(buf, "");
  1170.   for (i = object_list; i && (j>0); i = i->next)
  1171.     if (isname(name, i->name)) {
  1172.       if(i->carried_by) {
  1173.     if (strlen(PERS(i->carried_by, ch))>0) {
  1174.           sprintf(buf2,"%s carried by %s.\n\r",
  1175.             i->short_description,PERS(i->carried_by,ch));
  1176.           strcat(buf, buf2);
  1177.     }
  1178.       } else if(i->equipped_by) {
  1179.     if (strlen(PERS(i->equipped_by, ch))>0) {
  1180.           sprintf(buf2,"%s equipped by %s.\n\r",
  1181.           i->short_description,PERS(i->equipped_by,ch));
  1182.           strcat(buf, buf2);
  1183.     }
  1184.       } else if (i->in_obj) {
  1185.           sprintf(buf2,"%s in %s.\n\r",i->short_description,
  1186.             i->in_obj->short_description);
  1187.           strcat(buf, buf2);
  1188.       } else {
  1189.           sprintf(buf2,"%s in %s.\n\r",i->short_description,
  1190.         (i->in_room == NOWHERE ? "use but uncertain." : real_roomp(i->in_room)->name));
  1191.           strcat(buf, buf2);
  1192.          j--;
  1193.       }      
  1194.     }
  1195.  
  1196.   page_string(ch->desc, buf, 0);
  1197.  
  1198.   if(j==0)
  1199.     send_to_char("You are very confused.\n\r",ch);
  1200.   if(j==level>>1)
  1201.     send_to_char("No such object.\n\r",ch);
  1202. }
  1203.  
  1204.  
  1205. void spell_poison(byte level, struct char_data *ch,
  1206.   struct char_data *victim, struct obj_data *obj)
  1207. {
  1208.     struct affected_type af;
  1209.  
  1210.     assert(victim || obj);
  1211.  
  1212.   if (victim) {
  1213.     if (IS_NPC(ch)) {
  1214.      if (!IS_SET(ch->specials.act, ACT_DEADLY)) {
  1215.       if(!ImpSaveSpell(victim, SAVING_PARA, 0))    {
  1216.        af.type = SPELL_POISON;
  1217.        af.duration = level*2;
  1218.        af.modifier = -2;
  1219.        af.location = APPLY_STR;
  1220.        af.bitvector = AFF_POISON;
  1221.  
  1222.        affect_join(victim, &af, FALSE, FALSE);
  1223.  
  1224.        send_to_char("You feel very sick.\n\r", victim);
  1225.        if (!victim->specials.fighting)
  1226.      set_fighting(victim, ch);
  1227.      } else {
  1228.        return;
  1229.      }
  1230.     } else {
  1231.       if (!ImpSaveSpell(victim, SAVING_PARA, 0)) {
  1232.     act("Deadly poison fills your veins.",TRUE, ch, 0, 0, TO_CHAR);
  1233.     damage(victim, victim, MAX(10, GET_HIT(victim)*2), SPELL_POISON);
  1234.       } else {
  1235.     return;
  1236.       }
  1237.     }
  1238.    } else {
  1239.       if(!ImpSaveSpell(victim, SAVING_PARA, 0))    {
  1240.        af.type = SPELL_POISON;
  1241.        af.duration = level*2;
  1242.        af.modifier = -2;
  1243.        af.location = APPLY_STR;
  1244.        af.bitvector = AFF_POISON;
  1245.  
  1246.        affect_join(victim, &af, FALSE, FALSE);
  1247.  
  1248.        send_to_char("You feel very sick.\n\r", victim);     
  1249.       }
  1250.     }
  1251.   } else { /* Object poison */
  1252.     if ((obj->obj_flags.type_flag == ITEM_DRINKCON) ||
  1253.         (obj->obj_flags.type_flag == ITEM_FOOD)) {
  1254.       obj->obj_flags.value[3] = 1;
  1255.     }
  1256.   }
  1257. }
  1258.  
  1259.  
  1260. void spell_protection_from_evil(byte level, struct char_data *ch,
  1261.   struct char_data *victim, struct obj_data *obj)
  1262. {
  1263.   struct affected_type af;
  1264.  
  1265.     assert(victim);
  1266.  
  1267.   if (!affected_by_spell(victim, SPELL_PROTECT_FROM_EVIL) ) {
  1268.     af.type      = SPELL_PROTECT_FROM_EVIL;
  1269.     af.duration  = 24;
  1270.     af.modifier  = 0;
  1271.     af.location  = APPLY_NONE;
  1272.     af.bitvector = 0;
  1273.     affect_to_char(victim, &af);
  1274.     send_to_char("You have a righteous feeling!\n\r", victim);
  1275.   }
  1276. }
  1277.  
  1278.  
  1279. void spell_remove_curse(byte level, struct char_data *ch,
  1280.   struct char_data *victim, struct obj_data *obj)
  1281. {
  1282.  
  1283.   assert(ch && (victim || obj));
  1284.  
  1285.   if (obj) {
  1286.     if (IS_SET(obj->obj_flags.extra_flags, ITEM_NODROP)) {
  1287.       act("$p briefly glows blue.", TRUE, ch, obj, 0, TO_CHAR);
  1288.       REMOVE_BIT(obj->obj_flags.extra_flags, ITEM_NODROP);
  1289.     }
  1290.   } else {      /* Then it is a PC | NPC */
  1291.     if (affected_by_spell(victim, SPELL_CURSE) ) {
  1292.       act("$n briefly glows red, then blue.",FALSE,victim,0,0,TO_ROOM);
  1293.       act("You feel better.",FALSE,victim,0,0,TO_CHAR);
  1294.       affect_from_char(victim, SPELL_CURSE);
  1295.     }
  1296.     if (IS_PC(ch) && IS_PC(victim))
  1297.       GET_ALIGNMENT(ch)+=2;
  1298.   }
  1299. }
  1300.  
  1301.  
  1302. void spell_remove_poison(byte level, struct char_data *ch,
  1303.   struct char_data *victim, struct obj_data *obj)
  1304. {
  1305.  
  1306.   assert(ch && (victim || obj));
  1307.  
  1308.   if (victim) {
  1309.     if(affected_by_spell(victim,SPELL_POISON)) {
  1310.       affect_from_char(victim,SPELL_POISON);
  1311.       act("A warm feeling runs through your body.",FALSE,victim,0,0,TO_CHAR);
  1312.       act("$N looks better.",FALSE,ch,0,victim,TO_ROOM);
  1313.     }
  1314.   } else {
  1315.     if ((obj->obj_flags.type_flag == ITEM_DRINKCON) ||
  1316.         (obj->obj_flags.type_flag == ITEM_FOOD)) {
  1317.       obj->obj_flags.value[3] = 0;
  1318.       act("The $p steams briefly.",FALSE,ch,obj,0,TO_CHAR);
  1319.     }
  1320.   }
  1321. }
  1322.  
  1323.  
  1324.  
  1325. void spell_fireshield(byte level, struct char_data *ch,
  1326.   struct char_data *victim, struct obj_data *obj)
  1327. {
  1328.   struct affected_type af;
  1329.  
  1330.   if (!affected_by_spell(victim, SPELL_FIRESHIELD) ) {
  1331.  
  1332.     act("$n is surrounded by a glowing red aura.",TRUE,victim,0,0,TO_ROOM);
  1333.         act("You start glowing red.",TRUE,victim,0,0,TO_CHAR);
  1334.  
  1335.     af.type      = SPELL_FIRESHIELD;
  1336.     af.duration  = (level<LOW_IMMORTAL) ? 3 : level;
  1337.     af.modifier  = 0;
  1338.     af.location  = APPLY_NONE;
  1339.     af.bitvector = AFF_FIRESHIELD;
  1340.     affect_to_char(victim, &af);
  1341.   }
  1342. }
  1343.  
  1344. void spell_sanctuary(byte level, struct char_data *ch,
  1345.   struct char_data *victim, struct obj_data *obj)
  1346. {
  1347.   struct affected_type af;
  1348.  
  1349.   if ((!affected_by_spell(victim, SPELL_SANCTUARY)) && 
  1350.       (!IS_AFFECTED(victim, AFF_SANCTUARY))) {
  1351.  
  1352.     act("$n is surrounded by a white aura.",TRUE,victim,0,0,TO_ROOM);
  1353.         act("You start glowing.",TRUE,victim,0,0,TO_CHAR);
  1354.  
  1355.     af.type      = SPELL_SANCTUARY;
  1356.     af.duration  = (level<LOW_IMMORTAL) ? 3 : level;
  1357.     af.modifier  = 0;
  1358.     af.location  = APPLY_NONE;
  1359.     af.bitvector = AFF_SANCTUARY;
  1360.     affect_to_char(victim, &af);
  1361.   }
  1362. }
  1363.  
  1364.  
  1365.  
  1366. void spell_sleep(byte level, struct char_data *ch,
  1367.   struct char_data *victim, struct obj_data *obj)
  1368. {
  1369.   struct affected_type af;
  1370.  
  1371.     assert(victim);
  1372.  
  1373.   if (IsImmune(victim, IMM_SLEEP)) {
  1374.     FailSleep(victim, ch);
  1375.     return;
  1376.   }
  1377.   if (IsResist(victim, IMM_SLEEP)) {
  1378.     if (saves_spell(victim, SAVING_SPELL)) {
  1379.        FailSleep(victim, ch);
  1380.        return;
  1381.      }
  1382.     if (saves_spell(victim, SAVING_SPELL)) {
  1383.        FailSleep(victim, ch);
  1384.        return;
  1385.      }
  1386.   } else if (!IsSusc(victim, IMM_SLEEP)) {
  1387.     if (saves_spell(victim, SAVING_SPELL)) {
  1388.        FailSleep(victim, ch);
  1389.        return;
  1390.      }    
  1391.   }
  1392.  
  1393.     af.type      = SPELL_SLEEP;
  1394.     af.duration  = 4+level;
  1395.     af.modifier  = 0;
  1396.     af.location  = APPLY_NONE;
  1397.     af.bitvector = AFF_SLEEP;
  1398.     affect_join(victim, &af, FALSE, FALSE);
  1399.  
  1400.     if (GET_POS(victim)>POSITION_SLEEPING)    {
  1401.       act("You feel very sleepy ..... zzzzzz",FALSE,victim,0,0,TO_CHAR);
  1402.       act("$n go to sleep.",TRUE,victim,0,0,TO_ROOM);
  1403.         GET_POS(victim)=POSITION_SLEEPING;
  1404.     }
  1405. }
  1406.  
  1407.  
  1408.  
  1409. void spell_strength(byte level, struct char_data *ch,
  1410.   struct char_data *victim, struct obj_data *obj)
  1411. {
  1412.   struct affected_type af;
  1413.  
  1414.   assert(victim);
  1415.  
  1416.  
  1417.   if (!affected_by_spell(victim,SPELL_STRENGTH)) {
  1418.      act("You feel stronger.", FALSE, victim,0,0,TO_CHAR);
  1419.      act("$n seems stronger!\n\r",
  1420.       FALSE, victim, 0, 0, TO_ROOM);
  1421.      af.type      = SPELL_STRENGTH;
  1422.      af.duration  = 2*level;
  1423.      if (IS_NPC(victim))
  1424.         if (level >= CREATOR) {
  1425.       af.modifier = 25 - GET_STR(victim);
  1426.         } else
  1427.         af.modifier = number(1,6);
  1428.      else {
  1429.  
  1430.        if (HasClass(ch, CLASS_WARRIOR)) 
  1431.            af.modifier = number(1,8);
  1432.        else if (HasClass(ch, CLASS_CLERIC) ||
  1433.         HasClass(ch, CLASS_THIEF))
  1434.            af.modifier = number(1,6);
  1435.        else 
  1436.      af.modifier = number(1,4);
  1437.      }
  1438.      af.location  = APPLY_STR;
  1439.      af.bitvector = 0;
  1440.      affect_to_char(victim, &af);
  1441.    } else {
  1442.  
  1443.   act("Nothing seems to happen.", FALSE, ch,0,0,TO_CHAR);
  1444.  
  1445.   }
  1446. }
  1447.  
  1448.  
  1449.  
  1450. void spell_ventriloquate(byte level, struct char_data *ch,
  1451.   struct char_data *victim, struct obj_data *obj)
  1452. {
  1453.     /* Not possible!! No argument! */
  1454. }
  1455.  
  1456.  
  1457.  
  1458. void spell_word_of_recall(byte level, struct char_data *ch,
  1459.   struct char_data *victim, struct obj_data *obj)
  1460. {
  1461.   extern int top_of_world;
  1462.   int location;
  1463.  
  1464.   void do_look(struct char_data *ch, char *argument, int cmd);
  1465.  
  1466.   assert(victim);
  1467.  
  1468.   if (IS_NPC(victim))
  1469.      return;
  1470.  
  1471.   /*  loc_nr = GET_HOME(ch); */
  1472.  
  1473.   if (victim->player.hometown) {
  1474.     location = victim->player.hometown;
  1475.   } else {
  1476.     location = 3001;
  1477.   }
  1478.  
  1479.   if (!real_roomp(location))    {
  1480.     send_to_char("You are completely lost.\n\r", victim);
  1481.     location = 0;
  1482.     return;
  1483.   }
  1484.  
  1485.   if (!IsOnPmp(victim->in_room)) {
  1486.     send_to_char("You can't recall!, you're on a different plane!\n\r", 
  1487.          victim);
  1488.     return;
  1489.   }
  1490.  
  1491.     /* a location has been found. */
  1492.  
  1493.   act("$n disappears.", TRUE, victim, 0, 0, TO_ROOM);
  1494.   char_from_room(victim);
  1495.   char_to_room(victim, location);
  1496.   act("$n appears in the middle of the room.", TRUE, victim, 0, 0, TO_ROOM);
  1497.   do_look(victim, "",15);
  1498.  
  1499. }
  1500.  
  1501.  
  1502. void spell_summon(byte level, struct char_data *ch,
  1503.   struct char_data *victim, struct obj_data *obj)
  1504. {
  1505.   struct char_data *tmp;
  1506.   struct room_data *rp;
  1507.   int count;
  1508.  
  1509.   assert(ch && victim);
  1510.  
  1511.   if (victim->in_room <= NOWHERE) {
  1512.     send_to_char("Couldn't find any of those.\n\r", ch);
  1513.     return;
  1514.   }
  1515.  
  1516.   if ((rp = real_roomp(ch->in_room)) == NULL)
  1517.     return;
  1518.  
  1519.   if (IS_SET(rp->room_flags, NO_SUM) || IS_SET(rp->room_flags, NO_MAGIC)) {
  1520.     send_to_char("Eldritch wizardry obstructs thee.\n\r", ch);
  1521.     return;
  1522.   }
  1523.  
  1524.   if (IS_SET(rp->room_flags, TUNNEL)) {
  1525.     send_to_char("There is no room in here to summon!\n\r", ch);
  1526.     return;
  1527.   }
  1528.  
  1529.   if ((rp->sector_type == SECT_AIR) || rp->sector_type == SECT_UNDERWATER) {
  1530.     send_to_char("Strange powers block your summons\n", ch);
  1531.     return;
  1532.   }
  1533.  
  1534.   if (check_peaceful(ch, "Ancient powers obstruct thy magik\n"))
  1535.     return;
  1536.  
  1537.   if (check_peaceful(victim, "")) {
  1538.     send_to_char("You cannot get past the magical defenses.\n\r", ch);
  1539.     return;
  1540.   }
  1541.  
  1542.   if (IS_SET(real_roomp(victim->in_room)->room_flags, NO_SUM)) {
  1543.     send_to_char("Ancient Magiks bar your path.\n\r", ch);
  1544.     return;
  1545.   }
  1546.  
  1547.   if (victim->specials.fighting) {
  1548.     send_to_char("You can't get a clear fix on them\n", ch);
  1549.     return;
  1550.   }
  1551.  
  1552.   if (!IS_PC(victim)) {
  1553.       count = 0;
  1554.       for (tmp=real_roomp(victim->in_room)->people; 
  1555.        tmp; tmp = tmp->next_in_room) {
  1556.     count++;
  1557.       }
  1558.       
  1559.       if (count==0) {
  1560.     send_to_char("You failed.\n\r", ch);
  1561.     return;
  1562.       } else {
  1563.         count = number(0,count);
  1564.     
  1565.         for (tmp=real_roomp(victim->in_room)->people; 
  1566.          count && tmp;
  1567.          tmp = tmp->next_in_room, count--)
  1568.       ;
  1569.     
  1570.         if (tmp) {
  1571.       RawSummon(tmp, ch);
  1572.         } else {
  1573.       send_to_char("You failed\n\r", ch);
  1574.       return;
  1575.     }
  1576.       }
  1577.     } else {
  1578.       RawSummon(victim, ch);
  1579.     }
  1580.  
  1581. }
  1582.  
  1583.  
  1584. void RawSummon( struct char_data *v, struct char_data *c)
  1585. {
  1586.   sh_int target;
  1587.   struct char_data *tmp;
  1588.   struct obj_data *o, *n;
  1589.   int    j, i;
  1590.   extern char EasySummon;
  1591.   char buf[400];  
  1592.  
  1593.   if (IS_NPC(v) && (!IS_SET(v->specials.act, ACT_POLYSELF)) &&
  1594.       (GetMaxLevel(v) > GetMaxLevel(c)+3)) { 
  1595.     act("$N struggles, and all of $S items are destroyed!", TRUE, c, 0, v, TO_CHAR);
  1596.     /* remove objects from victim */
  1597.     for (j = 0; j < MAX_WEAR; j++) {
  1598.       if (v->equipment[j]) {
  1599.          o = unequip_char(v, j);
  1600.      extract_obj(o);
  1601.        }
  1602.     }
  1603.     for (o = v->carrying; o; o = n) {
  1604.       n = o->next_content;
  1605.       obj_from_char(o);
  1606.       extract_obj(o);
  1607.     }
  1608.     AddHated(v, c);
  1609.   } else {
  1610.     if (!EasySummon) {
  1611.       send_to_char("A wave of nausea overcomes you.  You collapse!\n\r",c);
  1612.       WAIT_STATE(c, PULSE_VIOLENCE*6);
  1613.       GET_POS(c) = POSITION_STUNNED;
  1614.     }
  1615.   }
  1616.  
  1617.   act("$n disappears suddenly.",TRUE,v,0,0,TO_ROOM);
  1618.   target = c->in_room;
  1619.   char_from_room(v);
  1620.   char_to_room(v,target);
  1621.   
  1622.   act("$n arrives suddenly.",TRUE,v,0,0,TO_ROOM);
  1623.   
  1624.   sprintf(buf, "%s has summoned you!\n\r", (IS_NPC(c)?c->player.short_descr:GET_NAME(c)));
  1625.   send_to_char(buf, v);
  1626.   do_look(v,"",15);
  1627.  
  1628.   for (tmp = real_roomp(v->in_room)->people; tmp; tmp = tmp->next_in_room) {
  1629.     if (IS_NPC(tmp) && !(IS_SET(tmp->specials.act,ACT_POLYSELF)) &&
  1630.     ((IS_SET(tmp->specials.act, ACT_AGGRESSIVE) ||
  1631.      (IS_SET(tmp->specials.act, ACT_META_AGG))))) {
  1632.       act("$n growls at you", 1, tmp, 0, c, TO_VICT);
  1633.       act("$n growls at $N", 1, tmp, 0, c, TO_NOTVICT);
  1634.       i = number(0,6);
  1635.       if (i==0) {
  1636.     if (CAN_SEE(tmp, c)) {
  1637.        hit(tmp, c, TYPE_UNDEFINED);
  1638.     }
  1639.       }
  1640.     }
  1641.   } 
  1642. }
  1643.  
  1644.  
  1645. void spell_charm_person(byte level, struct char_data *ch,
  1646.   struct char_data *victim, struct obj_data *obj)
  1647. {
  1648.   struct affected_type af;
  1649.  
  1650.   void add_follower(struct char_data *ch, struct char_data *leader);
  1651.   bool circle_follow(struct char_data *ch, struct char_data *victim);
  1652.   void stop_follower(struct char_data *ch);
  1653.  
  1654.   assert(ch && victim);
  1655.  
  1656.   if (victim == ch) {
  1657.     send_to_char("You like yourself even better!\n\r", ch);
  1658.     return;
  1659.   }
  1660.   
  1661.   if (!IS_AFFECTED(victim, AFF_CHARM) && !IS_AFFECTED(ch, AFF_CHARM)) {
  1662.     if (circle_follow(victim, ch)) {
  1663.       send_to_char("Sorry, following in circles can not be allowed.\n\r", ch);
  1664.       return;
  1665.     }
  1666.     
  1667.     if (!IsPerson(victim)) {
  1668.       send_to_char("Umm,  that's not a person....\n\r",ch);
  1669.       return;
  1670.     }
  1671.     
  1672.     
  1673.     if (GetMaxLevel(victim) > GetMaxLevel(ch)+3) {
  1674.       FailCharm(victim, ch);
  1675.       return;
  1676.     }
  1677.     
  1678.     if (too_many_followers(ch)) {
  1679.       act("$N takes one look at the size of your posse and justs says no!",
  1680.       TRUE, ch, ch->equipment[WIELD], victim, TO_CHAR);
  1681.       act("$N takes one look at the size of $n's posse and just says no!",
  1682.       TRUE, ch, ch->equipment[WIELD], victim, TO_ROOM);
  1683.       return;
  1684.     }
  1685.  
  1686.     if (IsImmune(victim, IMM_CHARM) || (WeaponImmune(victim))) {
  1687.       FailCharm(victim,ch);
  1688.       return;
  1689.     }
  1690.  
  1691.     if (IsResist(victim, IMM_CHARM)) {
  1692.       if (saves_spell(victim, SAVING_PARA)) {
  1693.     FailCharm(victim,ch);
  1694.     return;
  1695.       }
  1696.       
  1697.       if (saves_spell(victim, SAVING_PARA)) {
  1698.     FailCharm(victim,ch);
  1699.     return;
  1700.       }
  1701.     } else {
  1702.       if (!IsSusc(victim, IMM_CHARM)) {
  1703.     if (saves_spell(victim, SAVING_PARA)) {
  1704.       FailCharm(victim,ch);
  1705.       return;
  1706.     }
  1707.       }
  1708.     }
  1709.  
  1710.     if (victim->master)
  1711.       stop_follower(victim);
  1712.     
  1713.     add_follower(victim, ch);
  1714.     
  1715.     af.type      = SPELL_CHARM_PERSON;
  1716.     
  1717.     if (GET_CHR(ch))
  1718.       af.duration  = follow_time(ch);
  1719.     else
  1720.       af.duration  = 24*18;
  1721.  
  1722.     if (IS_GOOD(victim) && IS_GOOD(ch))
  1723.       af.duration *= 2;
  1724.     if (IS_EVIL(victim) && IS_EVIL(ch))
  1725.       af.duration  += af.duration >> 1;
  1726.  
  1727.     
  1728.     af.modifier  = 0;
  1729.     af.location  = 0;
  1730.     af.bitvector = AFF_CHARM;
  1731.     affect_to_char(victim, &af);
  1732.     
  1733.     act("Isn't $n just such a nice fellow?",FALSE,ch,0,victim,TO_VICT);
  1734.  
  1735.     if (!IS_PC(ch)) {
  1736.       REMOVE_BIT(victim->specials.act, ACT_AGGRESSIVE);
  1737.       SET_BIT(victim->specials.act, ACT_SENTINEL);
  1738.     }
  1739.   }
  1740. }
  1741.  
  1742.  
  1743.  
  1744. void spell_charm_monster(byte level, struct char_data *ch,
  1745.              struct char_data *victim, struct obj_data *obj)
  1746. {
  1747.   char buf[MAX_INPUT_LENGTH];
  1748.   struct affected_type af;
  1749.   
  1750.   void add_follower(struct char_data *ch, struct char_data *leader);
  1751.   bool circle_follow(struct char_data *ch, struct char_data *victim);
  1752.   void stop_follower(struct char_data *ch);
  1753.   
  1754.   assert(ch && victim);
  1755.  
  1756.   if (victim == ch) {
  1757.     send_to_char("You like yourself even better!\n\r", ch);
  1758.     return;
  1759.   }
  1760.  
  1761.   if (IsVeggie(victim)) {
  1762.     send_to_char("You can't charm a plant-creature!\n\r", ch);
  1763.     return;
  1764.   }
  1765.  
  1766.   if (GetMaxLevel(victim) > GetMaxLevel(ch)+3) {
  1767.     FailCharm(victim, ch);
  1768.     return;
  1769.   }
  1770.  
  1771.   if (too_many_followers(ch)) {
  1772.     act("$N takes one look at the size of your posse and justs says no!",
  1773.     TRUE, ch, 0, victim, TO_CHAR);
  1774.     act("$N takes one look at the size of $n's posse and just says no!",
  1775.     TRUE, ch, 0, victim, TO_ROOM);
  1776.     return;
  1777.   }
  1778.   
  1779.   if (!IS_AFFECTED(victim, AFF_CHARM) && !IS_AFFECTED(ch, AFF_CHARM)) {
  1780.     if (circle_follow(victim, ch)) {
  1781.       send_to_char("Sorry, following in circles can not be allowed.\n\r", ch);
  1782.       return;
  1783.     }
  1784.       if (IsImmune(victim, IMM_CHARM) || (WeaponImmune(victim))) {
  1785.           FailCharm(victim,ch);
  1786.              return;
  1787.       }
  1788.       if (IsResist(victim, IMM_CHARM)) {
  1789.          if (saves_spell(victim, SAVING_PARA)) {
  1790.           FailCharm(victim,ch);
  1791.              return;
  1792.      }
  1793.  
  1794.          if (saves_spell(victim, SAVING_PARA)) {
  1795.           FailCharm(victim,ch);
  1796.              return;
  1797.      }
  1798.        } else {
  1799.           if (!IsSusc(victim, IMM_CHARM)) {
  1800.          if (saves_spell(victim, SAVING_PARA)) {
  1801.             FailCharm(victim,ch);
  1802.         return;
  1803.          }
  1804.       }
  1805.        }
  1806.     
  1807.     if (victim->master)
  1808.       stop_follower(victim);
  1809.     
  1810.     add_follower(victim, ch);
  1811.     
  1812.     af.type      = SPELL_CHARM_PERSON;
  1813.     
  1814.     if (GET_CHR(ch))
  1815.       af.duration  = follow_time(ch);
  1816.     else
  1817.       af.duration  = 24*18;
  1818.  
  1819.     if (IS_GOOD(victim) && IS_GOOD(ch))
  1820.       af.duration *= 2;
  1821.     if (IS_EVIL(victim) && IS_EVIL(ch))
  1822.       af.duration  += af.duration >> 1;
  1823.  
  1824.     
  1825.     af.modifier  = 0;
  1826.     af.location  = 0;
  1827.     af.bitvector = AFF_CHARM;
  1828.     affect_to_char(victim, &af);
  1829.     
  1830.     act("Isn't $n just such a nice fellow?",FALSE,ch,0,victim,TO_VICT);
  1831.  
  1832.     if (!IS_PC(ch)) {
  1833.       REMOVE_BIT(victim->specials.act, ACT_AGGRESSIVE);
  1834.       SET_BIT(victim->specials.act, ACT_SENTINEL);
  1835.     }
  1836.  
  1837.   }
  1838. }
  1839.  
  1840.  
  1841. void spell_sense_life(byte level, struct char_data *ch,
  1842.   struct char_data *victim, struct obj_data *obj)
  1843. {
  1844.   struct affected_type af;
  1845.  
  1846.     assert(victim);
  1847.  
  1848.   if (!affected_by_spell(victim, SPELL_SENSE_LIFE)) {
  1849.     send_to_char("Your feel your awareness improve.\n\r", ch);
  1850.  
  1851.     af.type      = SPELL_SENSE_LIFE;
  1852.     af.duration  = 5*level;
  1853.     af.modifier  = 0;
  1854.     af.location  = APPLY_NONE;
  1855.     af.bitvector = AFF_SENSE_LIFE;
  1856.     affect_to_char(victim, &af);
  1857.   }
  1858.  
  1859. }
  1860.  
  1861. /* ***************************************************************************
  1862.  *                     Not cast-able spells                                  *
  1863.  * ************************************************************************* */
  1864.  
  1865.  
  1866. void sprintbit(unsigned long, char *[], char *);
  1867.  
  1868. void spell_identify(byte level, struct char_data *ch,
  1869.   struct char_data *victim, struct obj_data *obj)
  1870. {
  1871.   char buf[256], buf2[256];
  1872.   int i;
  1873.   bool found;
  1874.   
  1875.   struct time_info_data age(struct char_data *ch);
  1876.   
  1877.   /* Spell Names */
  1878.   extern char *spells[];
  1879.   
  1880.   /* For Objects */
  1881.   extern char *item_types[];
  1882.   extern char *extra_bits[];
  1883.   extern char *apply_types[];
  1884.   extern char *affected_bits[];
  1885.   extern char *affected_bits2[];
  1886.   extern char *immunity_names[];
  1887.   
  1888.   
  1889.   assert(ch && (obj || victim));
  1890.   
  1891.   if (obj) {
  1892.     send_to_char("You feel informed:\n\r", ch);
  1893.     
  1894.     sprintf(buf, "Object '%s', Item type: ", obj->name);
  1895.     sprinttype(GET_ITEM_TYPE(obj),item_types,buf2);
  1896.     strcat(buf,buf2); strcat(buf,"\n\r");
  1897.     send_to_char(buf, ch);
  1898.     
  1899.     if (obj->obj_flags.bitvector) {
  1900.       send_to_char("Item will give you following abilities:  ", ch);
  1901.       sprintbit((unsigned)obj->obj_flags.bitvector,affected_bits,buf);
  1902.       strcat(buf,"\n\r");
  1903.       send_to_char(buf, ch);
  1904.     }
  1905.     
  1906.     send_to_char("Item is: ", ch);
  1907.     sprintbit( (unsigned)obj->obj_flags.extra_flags,extra_bits,buf);
  1908.     strcat(buf,"\n\r");
  1909.     send_to_char(buf,ch);
  1910.     
  1911.     sprintf(buf,"Weight: %d, Value: %d, Rent cost: %d  %s\n\r",
  1912.         obj->obj_flags.weight, obj->obj_flags.cost, obj->obj_flags.cost_per_day, obj->obj_flags.cost_per_day>LIM_ITEM_COST_MIN?"[RARE]":" ");
  1913.     send_to_char(buf, ch);
  1914.  
  1915.     
  1916.     switch (GET_ITEM_TYPE(obj)) {
  1917.       
  1918.     case ITEM_SCROLL : 
  1919.     case ITEM_POTION :
  1920.       sprintf(buf, "Level %d spells of:\n\r",    obj->obj_flags.value[0]);
  1921.       send_to_char(buf, ch);
  1922.       if (obj->obj_flags.value[1] >= 1) {
  1923.     sprinttype(obj->obj_flags.value[1]-1,spells,buf);
  1924.     strcat(buf,"\n\r");
  1925.     send_to_char(buf, ch);
  1926.       }
  1927.       if (obj->obj_flags.value[2] >= 1) {
  1928.     sprinttype(obj->obj_flags.value[2]-1,spells,buf);
  1929.     strcat(buf,"\n\r");
  1930.     send_to_char(buf, ch);
  1931.       }
  1932.       if (obj->obj_flags.value[3] >= 1) {
  1933.     sprinttype(obj->obj_flags.value[3]-1,spells,buf);
  1934.     strcat(buf,"\n\r");
  1935.     send_to_char(buf, ch);
  1936.       }
  1937.       break;
  1938.       
  1939.     case ITEM_WAND : 
  1940.     case ITEM_STAFF : 
  1941.       sprintf(buf, "Has %d chages, with %d charges left.\n\r",
  1942.           obj->obj_flags.value[1],
  1943.           obj->obj_flags.value[2]);
  1944.       send_to_char(buf, ch);
  1945.       
  1946.       sprintf(buf, "Level %d spell of:\n\r",    obj->obj_flags.value[0]);
  1947.       send_to_char(buf, ch);
  1948.       
  1949.       if (obj->obj_flags.value[3] >= 1) {
  1950.     sprinttype(obj->obj_flags.value[3]-1,spells,buf);
  1951.     strcat(buf,"\n\r");
  1952.     send_to_char(buf, ch);
  1953.       }
  1954.       break;
  1955.       
  1956.     case ITEM_WEAPON :
  1957.       sprintf(buf, "Damage Dice is '%dD%d'\n\r",
  1958.           obj->obj_flags.value[1],
  1959.           obj->obj_flags.value[2]);
  1960.       send_to_char(buf, ch);
  1961.       break;
  1962.       
  1963.     case ITEM_ARMOR :
  1964.       sprintf(buf, "AC-apply is %d\n\r",
  1965.           obj->obj_flags.value[0]);
  1966.       send_to_char(buf, ch);
  1967.       break;
  1968.       
  1969.     }
  1970.     
  1971.     found = FALSE;
  1972.     
  1973.     for (i=0;i<MAX_OBJ_AFFECT;i++) {
  1974.       if ((obj->affected[i].location != APPLY_NONE) &&
  1975.       (obj->affected[i].modifier != 0)) {
  1976.     if (!found) {
  1977.       send_to_char("Can affect you as :\n\r", ch);
  1978.       found = TRUE;
  1979.     }
  1980.     
  1981.     sprinttype(obj->affected[i].location,apply_types,buf2);
  1982.     sprintf(buf,"    Affects : %s By ", buf2);
  1983.     send_to_char(buf,ch);
  1984.     switch(obj->affected[i].location) {
  1985.     case APPLY_M_IMMUNE:
  1986.     case APPLY_IMMUNE:
  1987.     case APPLY_SUSC:
  1988.        sprintbit(obj->affected[i].modifier,immunity_names,buf2);
  1989.        strcat(buf2,"\n\r");
  1990.        break;
  1991.     case APPLY_ATTACKS:
  1992.        sprintf(buf2,"%f\n\r", obj->affected[i].modifier/10);
  1993.        break;
  1994.         case APPLY_WEAPON_SPELL:
  1995.     case APPLY_EAT_SPELL:
  1996.        sprintf(buf2,"%s\n\r", spells[obj->affected[i].modifier-1]);
  1997.        break;
  1998.     case APPLY_SPELL:
  1999.        sprintbit(obj->affected[i].modifier,affected_bits, buf2);
  2000.        strcat(buf2,"\n\r");
  2001.        break;
  2002.  
  2003.      default:
  2004.        sprintf(buf2,"%d\n\r", obj->affected[i].modifier);
  2005.        break;
  2006.     }
  2007.     send_to_char(buf2,ch);
  2008.  
  2009.       }
  2010.     }
  2011.     
  2012.   } else {       /* victim */
  2013.     
  2014.     if (!IS_NPC(victim)) {
  2015.       struct time_info_data ma;
  2016.  
  2017.       age2(victim, &ma);
  2018.       sprintf(buf,"%d Years,  %d Months,  %d Days,  %d Hours old.\n\r",
  2019.           ma.year, ma.month,
  2020.           ma.day, ma.hours);
  2021.       send_to_char(buf,ch);
  2022.       
  2023.       sprintf(buf,"Height %dcm  Weight %dpounds \n\r",
  2024.           GET_HEIGHT(victim), GET_WEIGHT(victim));
  2025.       send_to_char(buf,ch);
  2026.       
  2027.       sprintf(buf,"Armor Class %d\n\r",victim->points.armor);
  2028.       send_to_char(buf,ch);
  2029.  
  2030.       if (level > 30) {
  2031.  
  2032.     sprintf(buf,"Str %d/%d, Int %d, Wis %d, Dex %d, Con %d, Ch %d\n\r",
  2033.     GET_STR(victim), GET_ADD(victim),
  2034.     GET_INT(victim),
  2035.     GET_WIS(victim),
  2036.     GET_DEX(victim),
  2037.     GET_CON(victim),
  2038.     GET_CHR(victim));
  2039.     send_to_char(buf,ch);
  2040.       }
  2041.       
  2042.     } else {
  2043.       send_to_char("You learn nothing new.\n\r", ch);
  2044.     }
  2045.   }
  2046.   
  2047. }
  2048.  
  2049.  
  2050. /* ***************************************************************************
  2051.  *                     NPC spells..                                          *
  2052.  * ************************************************************************* */
  2053.  
  2054. void spell_fire_breath(byte level, struct char_data *ch,
  2055.   struct char_data *victim, struct obj_data *obj)
  2056. {
  2057.     int dam;
  2058.     int hpch;
  2059.     struct obj_data *burn;
  2060.  
  2061.     assert(victim && ch);
  2062.     assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  2063.  
  2064.     hpch = GET_MAX_HIT(ch);
  2065.     hpch *= level;
  2066.     hpch /= GetMaxLevel(ch);
  2067.     if(hpch<10) hpch=10;
  2068.  
  2069.     dam = hpch;
  2070.  
  2071.     if ( saves_spell(victim, SAVING_BREATH) )
  2072.         dam >>= 1;
  2073.  
  2074.     MissileDamage(ch, victim, dam, SPELL_FIRE_BREATH);
  2075.  
  2076.     /* And now for the damage on inventory */
  2077.  
  2078. /*
  2079.   DamageStuff(victim, FIRE_DAMAGE);
  2080. */
  2081.  
  2082.            for (burn=victim->carrying ; 
  2083.          burn && (burn->obj_flags.type_flag!=ITEM_SCROLL) && 
  2084.         (burn->obj_flags.type_flag!=ITEM_WAND) &&
  2085.         (burn->obj_flags.type_flag!=ITEM_STAFF) &&
  2086.         (burn->obj_flags.type_flag!=ITEM_BOAT);
  2087.          burn=burn->next_content) {
  2088.          if (!saves_spell(victim, SAVING_BREATH) )     {
  2089.                if (burn)  {
  2090.                    act("$o burns",0,victim,burn,0,TO_CHAR);
  2091.                    extract_obj(burn);
  2092.                }
  2093.          }
  2094.     }
  2095. }
  2096.  
  2097.  
  2098. void spell_frost_breath(byte level, struct char_data *ch,
  2099.   struct char_data *victim, struct obj_data *obj)
  2100. {
  2101.     int dam;
  2102.     int hpch;
  2103.     struct obj_data *frozen;
  2104.  
  2105.     assert(victim && ch);
  2106.     assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  2107.  
  2108.     hpch = GET_MAX_HIT(ch);
  2109.     hpch *= level;
  2110.     hpch /= GetMaxLevel(ch);
  2111.     if(hpch<10) hpch=10;
  2112.  
  2113.     dam = hpch;
  2114.  
  2115.     if ( saves_spell(victim, SAVING_BREATH) )
  2116.         dam >>= 1;
  2117.  
  2118.     MissileDamage(ch, victim, dam, SPELL_FROST_BREATH);
  2119.  
  2120.     /* And now for the damage on inventory */
  2121.  
  2122.            for (frozen=victim->carrying ; 
  2123.                frozen && (frozen->obj_flags.type_flag!=ITEM_DRINKCON) && 
  2124.         (frozen->obj_flags.type_flag!=ITEM_POTION);
  2125.         frozen=frozen->next_content) {
  2126.  
  2127.                if (!saves_spell(victim, SAVING_BREATH) ) {
  2128.                  if (frozen) {
  2129.             act("$o shatters.",0,victim,frozen,0,TO_CHAR);
  2130.             extract_obj(frozen);
  2131.           }
  2132.         }
  2133.     }
  2134. }
  2135.  
  2136.  
  2137. void spell_acid_breath(byte level, struct char_data *ch,
  2138.   struct char_data *victim, struct obj_data *obj)
  2139. {
  2140.   int dam;
  2141.   int hpch;
  2142.   
  2143.   int apply_ac(struct char_data *ch, int eq_pos);
  2144.   
  2145.   assert(victim && ch);
  2146.   assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  2147.   
  2148.   hpch = GET_MAX_HIT(ch);
  2149.   hpch *= level;
  2150.   hpch /= GetMaxLevel(ch);
  2151.   if(hpch<10) hpch=10;
  2152.   
  2153.   dam = hpch;
  2154.   
  2155.   if ( saves_spell(victim, SAVING_BREATH) )
  2156.     dam >>= 1;
  2157.   
  2158.   MissileDamage(ch, victim, dam, SPELL_ACID_BREATH);
  2159.  
  2160. }
  2161.  
  2162.  
  2163. void spell_gas_breath(byte level, struct char_data *ch,
  2164.   struct char_data *victim, struct obj_data *obj)
  2165. {
  2166.     int dam;
  2167.     int hpch;
  2168.  
  2169.     assert(victim && ch);
  2170.     assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  2171.  
  2172.     hpch = GET_MAX_HIT(ch);
  2173.     hpch *= level;
  2174.     hpch /= GetMaxLevel(ch);
  2175.     if(hpch<10) hpch=10;
  2176.  
  2177.     dam = hpch;
  2178.  
  2179.     if ( saves_spell(victim, SAVING_BREATH) )
  2180.         dam >>= 1;
  2181.  
  2182.     MissileDamage(ch, victim, dam, SPELL_GAS_BREATH);
  2183.  
  2184.  
  2185. }
  2186.  
  2187.  
  2188. void spell_lightning_breath(byte level, struct char_data *ch,
  2189.   struct char_data *victim, struct obj_data *obj)
  2190. {
  2191.     int dam;
  2192.     int hpch;
  2193.  
  2194.     assert(victim && ch);
  2195.     assert((level >= 1) && (level <= ABS_MAX_LVL)); 
  2196.  
  2197.     hpch = GET_MAX_HIT(ch);
  2198.     hpch *= level;
  2199.     hpch /= GetMaxLevel(ch);
  2200.     if(hpch<10) hpch=10;
  2201.  
  2202.     dam = hpch;
  2203.  
  2204.     if ( saves_spell(victim, SAVING_BREATH) )
  2205.         dam >>= 1;
  2206.  
  2207.     MissileDamage(ch, victim, dam, SPELL_LIGHTNING_BREATH);
  2208.  
  2209.  
  2210. }
  2211.  
  2212.  
  2213.